package com.agou.core.util;

import java.sql.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;

/**
 * 日期类
 * 
 * @author agou
 * 
 */
public final class UtDate {
	/** 程序逻辑错误(103001)-无效的格式化字符串#0 */
	public static final int LeFormatError = 100001;
	/** 程序逻辑错误(103001)-非法的月份 */
	public static final int LeInvalidMonth = 103001;
	/** 程序逻辑错误(103002)-非法的日 */
	public static final int LeInvalidDay = 103002;
	/** 程序逻辑错误(103003)-每周的第一天不是星期一 */
	public static final int LeMondayNotFirstDayOfWeek = 103003;
	/** 程序逻辑错误(103004)-日期小于系统允许的最小日期 */
	public static final int LeLessThanMinimumDate = 103004;
	/** 程序逻辑错误(103005)-日期大于系统允许的最大日期 */
	public static final int LeMoreThanMaximumDate = 103005;
	
	
	public final static int DayMilliseconds = 86400000;

	/** 日期时间型字符串中年的位置(从0开始): 0 */
	private static final int posDatetimeYear = 0;

	/** 日期时间型字符串中月的位置(从0开始): 4 */
	//private static final int posDatetimeMonth = 4;

	/** 日期时间型字符串中日的位置(从0开始): 6 */
	//private static final int posDatetimeDay = 6;

	/** 日期时间型字符串中时的位置(从0开始): 8 */
	private static final int posDatetimeHour = 8;

	/** 日期时间型字符串中分的位置(从0开始): 10 */
	//private static final int posDatetimeMinute = 10;

	/** 日期时间型字符串中秒的位置(从0开始): 12 */
	//private static final int posDatetimeSecond = 12;

	/** 日期时间型字符串中毫秒的位置(从0开始): 14 */
	//private static final int posDatetimeMillisecond = 14;

	/** 最大日期 */
	public final static int maxDate = 29991231;

	/** 最小日期 */
	public final static int minDate = 18991231;

	/** 空日期(使用最小日期)-字符串型 */
	public final static String nullDate = "18991231";

	/** SQL空日期(使用最小日期, 已有单引号)-字符串型 */
	public final static String sqlNull = "'18991231'";

	/** 月份-1月份 */
	public final static int monthJanuary = 1;

	/** 月份-2月份 */
	public final static int monthFebruary = 2;

	/** 月份-3月份 */
	public final static int monthMarch = 3;

	/** 月份-4月份 */
	public final static int monthApril = 4;

	/** 月份-5月份 */
	public final static int monthMay = 5;

	/** 月份-6月份 */
	public final static int monthJune = 6;

	/** 月份-7月份 */
	public final static int monthJuly = 7;

	/** 月份-8月份 */
	public final static int monthAugust = 8;

	/** 月份-9月份 */
	public final static int monthSeptember = 9;

	/** 月份-10月份 */
	public final static int monthOctober = 10;

	/** 月份-11月份 */
	public final static int monthNovember = 11;

	/** 月份-12月份 */
	public final static int monthDecember = 12;

	/** 周-星期日 */
	public final static char weekSunday = '7';

	/** 周-星期一 */
	public final static char weekMonday = '1';

	/** 周-星期二 */
	public final static char weekTuesday = '2';

	/** 周-星期三 */
	public final static char weekWednesday = '3';

	/** 周-星期四 */
	public final static char weekThursday = '4';

	/** 周-星期五 */
	public final static char weekFriday = '5';

	/** 周-星期六 */
	public final static char weekSaturday = '6';

	/** 周-每周的第一天是星期一 */
	public final static char weekFirstDayOfWeek = weekMonday;

	/**
	 * 本系统中日期时间型字符串长度为17位, 格式为"YYYYMMDDhhmmssiii"
	 * <ul>
	 * <li>YYYY - 年
	 * <li>MM - 月
	 * <li>DD - 日
	 * <li>hh - 时
	 * <li>mm - 分
	 * <li>ss - 秒
	 * <li>iii - 毫秒
	 * </ul>
	 */
	private static final int lenDatetimeString = 17;


	/** 用于括起SQL格式日期的符号(') */
	private final static String _sqlSeparator = "'";
	/** 每天的毫秒数: 86400000 */
	
	/** 整数型日期, 与日历型日期对应 */
	private int _nDate;
	/** 整数形时间,与日历型时间相对应 **/
	private int _nTime;
	/** 日历型日期, 与整数型日期对应 */
	private Calendar _calendar = Calendar.getInstance();

	public UtDate() {
		setIntegerProperty();
		return;
	}

	/**
	 * 日期构造函数 使用java.util.Date对象构造日期
	 * 
	 * @param date
	 *            日期
	 */
	public UtDate(Date date) {
		this._calendar.setFirstDayOfWeek(Calendar.MONDAY);
		this._calendar.setTime(date);
		setIntegerProperty();
		valid(this._nDate);
		return;
	}

	/**
	 * 日期构造函数 使用java.util.Calendar对象构造日期
	 * <P>
	 * 注意: 如果提供的日期为空(null), 则取当前系统时间
	 * 
	 * @param date
	 *            日期
	 */
	public UtDate(Calendar date) {
		if (date != null) {
			this._calendar = date;
		}
		setIntegerProperty();
		return;
	}

	/**
	 * 日期构造函数 使用字符串对象构造日期（yyyy-MM-dd HH:mm:ss.SSS）
	 * 
	 * @param date
	 *            日期
	 */
	public UtDate(String date, String format) {
		SimpleDateFormat dateformat = new SimpleDateFormat(format);
		try {
			this._calendar.setTime(dateformat.parse(date));
		} catch (ParseException e) {
			throw new java.lang.IllegalArgumentException("无效的格式化字符串,提供的日期是["
					+ date + "]，提供的格式化串是[" + format + "]");
		}
		setIntegerProperty();
		return;
	}

	/**
	 * 日期构造函数 使用字符串对象构造日期
	 * <P>
	 * 此构造函数可以处理两种类型的日期字符串
	 * <ul>
	 * <li>日期型字符串, 格式是"YYYYMMDD", 其中YYYY-年(4位); MM-月(取值1至12, 不足两位时左补0);
	 * DD-日(不足两位时, 左补0).
	 * <li>日期时间型字符串,
	 * 格式参见SSResource.lenDatetimeString或UtDate.createDatetime()中关于日期时间型字符串的说明
	 * </ul>
	 * 
	 * @param date - 日期
	 */
	public UtDate(String date) {
		this._calendar.setFirstDayOfWeek(Calendar.MONDAY);
		if (date.length() == lenDatetimeString) {
			this._nDate = Integer.parseInt(date.substring(posDatetimeYear,posDatetimeHour));
		} else {
			this._nDate = Integer.parseInt(date);
		}
		valid(this._nDate);
		setCalendarProperty(this._calendar, this._nDate);
		return;
	}

	/**
	 * 日期构造函数 使用日期整数构造日期
	 * <P>
	 * 注意: 该日期整数必须与通过UtDate.getDate()方式得到的日期格式相同
	 * 
	 * @param date
	 *            日期
	 */
	public UtDate(int date) {
		this._calendar.setFirstDayOfWeek(Calendar.MONDAY);
		this._nDate = date;
		valid(this._nDate);
		setCalendarProperty(this._calendar, this._nDate);
		return;
	}

	public UtDate(int date, int time) {
		this._calendar.setFirstDayOfWeek(Calendar.MONDAY);
		this._nDate = date;
		this._nTime = time;
		valid(this._nDate);
		setCalendarProperty(this._calendar, this._nDate, this._nTime);
		return;
	}

	/**
	 * 日期构造函数 使用时间戳构造日期
	 * 
	 * @param timestamp
	 *            时间戳
	 */
	public UtDate(long timestamp) {
		Date d = new Date(timestamp);
		this._calendar.setFirstDayOfWeek(Calendar.MONDAY);
		this._calendar.setTime(d);
		setIntegerProperty();
		valid(this._nDate);
		return;
	}

	/**
	 * 日期构造函数 使用年、月、日构造日期
	 * 
	 * @param year
	 *            年
	 * @param month
	 *            月
	 * @param day
	 *            日
	 */
	public UtDate(int year, int month, int day) {
		this._calendar.clear();
		this._calendar.setFirstDayOfWeek(Calendar.MONDAY);
		this._calendar.set(year, month - 1, day);
		setIntegerProperty();
		valid(this._nDate);
		return;
	}

	public UtDate(int year, int month, int day, int hourOfDay, int minute,
			int second) {
		this._calendar.clear();
		this._calendar.setFirstDayOfWeek(Calendar.MONDAY);
		this._calendar.set(year, month - 1, day, hourOfDay, minute, second);
		setIntegerProperty();
		valid(this._nDate);
		return;
	}

	/**
	 * 根据整数型日期, 设置日历型日期
	 */
	private void setCalendarProperty(Calendar cal, int date) {
		int year, month, day;
		year = date / 10000;
		month = (date - year * 10000) / 100;
		day = date - year * 10000 - month * 100;
		cal.clear();
		cal.setFirstDayOfWeek(Calendar.MONDAY);
		cal.set(year, month - 1, day);
		return;
	}

	private void setCalendarProperty(Calendar cal, int date, int time) {
		int year, month, day;
		year = date / 10000;
		month = (date - year * 10000) / 100;
		day = date - year * 10000 - month * 100;
		if (time > 0) {
			int hourOfDay, minute, second;
			hourOfDay = time / 10000;
			minute = (time - hourOfDay * 10000) / 100;
			second = time - hourOfDay * 10000 - minute * 100;
			cal.clear();
			cal.setFirstDayOfWeek(Calendar.MONDAY);
			cal.set(year, month - 1, day, hourOfDay, minute, second);
		} else {
			cal.set(year, month - 1, day);
		}
		return;
	}

	/**
	 * 根据日历型日期, 设置整数型日期
	 */
	private void setIntegerProperty() {
		this._nDate = this._calendar.get(Calendar.YEAR) * 10000
				+ (this._calendar.get(Calendar.MONTH) + 1) * 100
				+ this._calendar.get(Calendar.DAY_OF_MONTH);
		this._nTime = this._calendar.get(Calendar.HOUR_OF_DAY) * 10000
				+ this._calendar.get(Calendar.MINUTE) * 100
				+ this._calendar.get(Calendar.SECOND);
		return;
	}

	/**
	 * 日期设置函数 使用日期整数设置日期
	 * 
	 * @param date
	 *            日期
	 */
	public void setDate(int date) {
		this._nDate = date;
		valid(this._nDate);
		setCalendarProperty(this._calendar, this._nDate);
	}

	/**
	 * 日期设置函数 使用字符串对象设置日期
	 * <P>
	 * 字符串内的日期格式必须是 YYYYMMDD 格式, 说明如下
	 * <UL>
	 * <LI>YYYY 四位数字, 表示年
	 * <LI>MM 两位数字, 表示月, 不足两位时, 左补0
	 * <LI>DD 两位数字, 表示日, 不足两位时, 左补0
	 * </UL>
	 * 
	 * @param date
	 *            日期
	 */
	public void setDate(String date) {
		this._nDate = Integer.parseInt(date);
		valid(this._nDate);
		setCalendarProperty(this._calendar, this._nDate);
	}

	/**
	 * 日期设置函数 使用java.util.Date对象设置日期
	 * 
	 * @param date
	 *            日期
	 */
	public void setDate(Date date) {
		this._calendar.clear();
		this._calendar.setTime(date);
		setIntegerProperty();
		valid(this._nDate);
		return;
	}

	/**
	 * 日期设置函数 使用年、月、日设置日期
	 * 
	 * @param year
	 *            年
	 * @param month
	 *            月
	 * @param day
	 *            日
	 */
	public void setDate(int year, int month, int day) {
		this._calendar.clear();
		this._calendar.setFirstDayOfWeek(Calendar.MONDAY);
		this._calendar.set(year, month - 1, day);
		setIntegerProperty();
		valid(this._nDate);
		return;
	}

	public void setDate(int year, int month, int day, int hourOfDay,
			int minute, int second) {
		this._calendar.clear();
		this._calendar.setFirstDayOfWeek(Calendar.MONDAY);
		this._calendar.set(year, month - 1, day, hourOfDay, minute, second);
		setIntegerProperty();
		valid(this._nDate);
		return;
	}

	/**
	 * 检查所给日期是否是有效的日期
	 * 
	 * @param date
	 *            整数型日期
	 * @throws SSLogiException.leMoreThanMaximumDate
	 *             日期大于系统允许的最大日期
	 * @throws SSLogiException.leLessThanMinimumDate
	 *             日期小于系统允许的最小日期
	 * @throws SSLogiException.leInvalidMonth
	 *             不合法的月份
	 * @throws SSLogiException.leInvalidDay
	 *             不合法的日
	 */
	public static void valid(int date) {
		if (date > UtDate.maxDate) {
			throw new java.lang.IllegalArgumentException("日期大于系统允许的最大日期，"
					+ "系统最大日期是: " + UtDate.maxDate + ", 用户提供的日期是: " + date);
		}
		if (date < UtDate.minDate) {
			throw new java.lang.IllegalArgumentException("日期小于系统允许的最小日期，"
					+ "系统最小日期是: " + UtDate.minDate + ", 用户提供的日期是: " + date);
		}

		/** 以下检查非法月份 */
		int year = date / 10000;
		int month = (date - year * 10000) / 100;
		if (month > monthDecember) {
			throw new java.lang.IllegalArgumentException("非法的月份，"
					+ "用户提供的日期是: " + date + ",月份是: " + month);
		}

		/** 以下检查日 */
		int day = date - year * 10000 - month * 100;
		int nEndDay;
		switch (month) {
		case monthJanuary: // 月份-1月份
		case monthMarch: // 月份-3月份
		case monthMay: // 月份-5月份
		case monthJuly: // 月份-7月份
		case monthAugust: // 月份-8月份
		case monthOctober: // 月份-10月份
		case monthDecember: // 月份-12月份
			nEndDay = 31;
			break;
		case monthFebruary: // 月份-2月份
			if (UtDate.isLeapYear(year))
				nEndDay = 29; // 闰年29天
			else
				nEndDay = 28; // 平年28天
			break;
		case monthApril: // 月份-4月份
		case monthJune: // 月份-6月份
		case monthSeptember: // 月份-9月份
		case monthNovember: // 月份-11月份
		default:
			nEndDay = 30;
			break;
		}
		if (day > nEndDay) {
			throw new java.lang.IllegalArgumentException("非法的日，" + "用户提供的日期是: "
					+ date + ",日是: " + month);
		}
		return;
	}

	/**
	 * 检查所给的年份是否是闰年
	 * 
	 * @param year
	 *            年
	 * @return 检查结果: true - 是闰年; false - 是平年
	 */
	public static boolean isLeapYear(int year) {
		if (year / 4 * 4 != year) {
			return false; // 不能被4整除
		} else if (year / 100 * 100 != year) {
			return true; // 能被4整除，不能被100整除
		} else if (year / 400 * 400 != year) {
			return false; // 能被100整除，不能被400整除
		} else {
			return true; // 能被400整除
		}
	}

	/**
	 * 检查当前日期的年份是否是闰年
	 * 
	 * @return 检查结果: true - 是闰年; false - 是平年
	 */
	public boolean isLeapYear() {
		return isLeapYear(this.getYear());
	}

	/**
	 * 取整数型日期
	 * <p>
	 * 注意: 整数型日期可以直接用于比较两个日期的大小, 但不能通过直接相减整数型日期计算两个日期的间隔天数
	 * 
	 * @return 整数型日期
	 */
	public int getDate() {
		return this._nDate;
	}

	/**
	 * 取年
	 * 
	 * @return 年
	 */
	public int getYear() {
		return this._nDate / 10000;
	}

	/**
	 * 取月
	 * 
	 * @return 月
	 */
	public int getMonth() {
		return (this._nDate - (this._nDate / 10000) * 10000) / 100;
	}

	/**
	 * 取日
	 * 
	 * @return 日
	 */
	public int getDay() {
		return this._nDate - (this._nDate / 100) * 100;
	}

	public int getTime() {
		return _nTime;
	}

	public int getHour() {
		return this._nTime / 10000;
	}

	public int getMinute() {
		return (this._nTime - this._nTime / 10000 * 10000) / 100;
	}

	public int getSecond() {
		return this._nTime - this._nTime / 100 * 100;
	}

	public long getTimeInMillis() {
		return _calendar.getTimeInMillis();
	}

	/**
	 * 取符合SQL日期格式的字符串型日期
	 * <P>
	 * 取到的SQL格式日期, 仅可用于数据库操作的SQL语句中, 不要用于其它用途;
	 * <P>
	 * 此方法返回的字符串已经用单引号括起
	 * 
	 * @return SQL格式日期
	 */
	public String sqlFormat() {
		return _sqlSeparator + this._nDate + _sqlSeparator;
	}

	/**
	 * 取当前日期是星期几
	 * 
	 * @return 星期, 内容为
	 *         weekSunday、weekMonday、weekTuesday、weekWednesday、weekThursday
	 *         、weekFriday、weekSaturday
	 */
	public char getDayOfWeek() {
		int day = this._calendar.get(Calendar.DAY_OF_WEEK);
		switch (day) {
		case Calendar.SUNDAY:
			return weekSunday;
		case Calendar.MONDAY:
			return weekMonday;
		case Calendar.TUESDAY:
			return weekTuesday;
		case Calendar.WEDNESDAY:
			return weekWednesday;
		case Calendar.THURSDAY:
			return weekThursday;
		case Calendar.FRIDAY:
			return weekFriday;
		default:
			return weekSaturday;
		}
	}

	/**
	 * 取当前日期所在周的最后一天(周日)的日期
	 * 
	 * @return 整数型日期
	 */
	public int getEndOfWeek() {
		Calendar c = Calendar.getInstance();
		c.clear();
		c.setFirstDayOfWeek(Calendar.MONDAY);
		c.set(this.getYear(), this.getMonth() - 1, this.getDay());
		switch (c.get(Calendar.DAY_OF_WEEK)) {
		case Calendar.MONDAY:
			c.add(Calendar.DATE, 6);
			break;
		case Calendar.TUESDAY:
			c.add(Calendar.DATE, 5);
			break;
		case Calendar.WEDNESDAY:
			c.add(Calendar.DATE, 4);
			break;
		case Calendar.THURSDAY:
			c.add(Calendar.DATE, 3);
			break;
		case Calendar.FRIDAY:
			c.add(Calendar.DATE, 2);
			break;
		case Calendar.SATURDAY:
			c.add(Calendar.DATE, 1);
			break;
		default: // Calendar.SUNDAY:
			break;
		}
		return c.get(Calendar.YEAR) * 10000 + (c.get(Calendar.MONTH) + 1) * 100
				+ c.get(Calendar.DAY_OF_MONTH);
	}

	/**
	 * 取当前日期所在旬的最后一天的日期
	 * 
	 * @return 整数型日期
	 */
	public int getEndOfTenDays() {
		if (this.getDay() <= 10) {
			return this.getYear() * 10000 + this.getMonth() * 100 + 10;
		} else if (this.getDay() <= 20) {
			return this.getYear() * 10000 + this.getMonth() * 100 + 20;
		} else {
			return getEndOfMonth();
		}
	}

	/**
	 * 取当前日期所在月份的最后一天的日期
	 * 
	 * @return 整数型日期
	 */
	public int getEndOfMonth() {
		int year = this.getYear();
		int month = this.getMonth();

		switch (month) {
		case monthJanuary: // 月份-1月份
		case monthMarch: // 月份-3月份
		case monthMay: // 月份-5月份
		case monthJuly: // 月份-7月份
		case monthAugust: // 月份-8月份
		case monthOctober: // 月份-10月份
		case monthDecember: // 月份-12月份
			return year * 10000 + month * 100 + 31;
		case monthFebruary: // 月份-2月份
			if (isLeapYear(year)) {
				return year * 10000 + month * 100 + 29; // 闰年29天
			} else {
				return year * 10000 + month * 100 + 28; // 平年28天
			}
		case monthApril: // 月份-4月份
		case monthJune: // 月份-6月份
		case monthSeptember: // 月份-9月份
		case monthNovember: // 月份-11月份
			return year * 10000 + month * 100 + 30;
		default:
			throw new IllegalStateException("错误的月份：" + month);
		}
	}

	/**
	 * 取当前日期所在季度的最后一天的日期
	 * 
	 * @return 整数型日期
	 */
	public int getEndOfQuarter() {
		if (this.getMonth() <= monthMarch) { // 三月份以前
			return this.getYear() * 10000 + 331;
		} else if (this.getMonth() <= monthJune) { // 六月份以前
			return this.getYear() * 10000 + 630;
		} else if (this.getMonth() <= monthSeptember) { // 九月份以前
			return this.getYear() * 10000 + 930;
		} else { // 六月份以后
			return this.getYear() * 10000 + 1231;
		}
	}

	/**
	 * 取当前日期所在半年的最后一天的日期
	 * 
	 * @return 整数型日期
	 */
	public int getEndOfHalfYear() {
		if (this.getMonth() <= monthJune) { // 六月份以前
			return this.getYear() * 10000 + 630;
		} else { // 六月份以后
			return this.getYear() * 10000 + 1231;
		}
	}

	/**
	 * 取当前日期所在年的最后一天的日期
	 * 
	 * @return 整数型日期
	 */
	public int getEndOfYear() {
		return this.getYear() * 10000 + 1231;
	}

	/**
	 * 比较两个日期, 返回两个日期之间毫秒数
	 */
	public long compareTo(int date) {
		long lCur = this.getTimeInMillis();//this._calendar.getTime().getTime();
		Calendar calPar = Calendar.getInstance();
		setCalendarProperty(calPar, date);
		long lPar = calPar.getTime().getTime();
		return lCur - lPar;
	}

	/**
	 * 比较两个日期, 返回两个日期之间毫秒数
	 */
	public long compareTo(UtDate date) {
		return this.getTimeInMillis() - date.getTimeInMillis();
	}

	/**
	 * 在当前日期的基础上加指定天数
	 * <P>
	 * 注意, 此方法改变了对象的当前日期
	 * 
	 * @param amount
	 *            天数, 可以为负数
	 * @return 调整后的整数型日期
	 */
	public int addDay(int amount) {
		this._calendar.add(Calendar.DATE, amount);
		setIntegerProperty();
		return this._nDate;
	}

	/**
	 * 在当前日期的基础上加指定周数
	 * <P>
	 * 注意, 此方法改变了对象的当前日期
	 * 
	 * @param amount
	 *            周数, 可以为负数
	 * @return 调整后的整数型日期
	 */
	public int addWeek(int amount) {
		this._calendar.add(Calendar.DATE, amount * 7);
		setIntegerProperty();
		return this._nDate;
	}

	/**
	 * 在当前日期的基础上加指定旬数
	 * <P>
	 * 注意, 此方法改变了对象的当前日期
	 * 
	 * @param amount
	 *            旬数, 可以为负数
	 * @return 调整后的整数型日期
	 */
	public int addTenDay(int amount) {
		this._calendar.add(Calendar.MONTH, amount / 3);
		amount = amount % 3;
		if (amount > 0) {
			if (this._nDate + amount * 10 > this.getEndOfMonth()) {
				this._calendar.add(Calendar.MONTH, 1);
				this._calendar.add(Calendar.DATE, (amount - 3) * 10);
			} else {
				this._calendar.add(Calendar.DATE, amount * 10);
			}
		} else if (amount < 0) {
			if (this.getDay() + amount * 10 <= 0) {
				this._calendar.add(Calendar.MONTH, -1);
				this._calendar.add(Calendar.DATE, (3 - amount) * 10);
			} else {
				this._calendar.add(Calendar.DATE, amount * 10);
			}
		}
		setIntegerProperty();
		return this._nDate;
	}

	/**
	 * 在当前日期的基础上加指定月数
	 * <P>
	 * 注意, 此方法改变了对象的当前日期
	 * 
	 * @param amount
	 *            月数, 可以为负数
	 * @return 调整后的整数型日期
	 */
	public int addMonth(int amount) {
		this._calendar.add(Calendar.MONTH, amount);
		setIntegerProperty();
		return this._nDate;
	}

	/**
	 * 在当前日期的基础上加指定季数
	 * <P>
	 * 注意, 此方法改变了对象的当前日期
	 * 
	 * @param amount
	 *            季数, 可以为负数
	 * @return 调整后的整数型日期
	 */
	public int addQuarter(int amount) {
		this._calendar.add(Calendar.MONTH, amount * 3);
		setIntegerProperty();
		return this._nDate;
	}

	/**
	 * 在当前日期的基础上加指定半年数
	 * <P>
	 * 注意, 此方法改变了对象的当前日期
	 * 
	 * @param amount
	 *            半年数, 可以为负数
	 * @return 调整后的整数型日期
	 */
	public int addHalfYear(int amount) {
		this._calendar.add(Calendar.MONTH, amount * 6);
		setIntegerProperty();
		return this._nDate;
	}

	/**
	 * 在当前日期的基础上加指定年数
	 * <P>
	 * 注意, 此方法改变了对象的当前日期
	 * 
	 * @param amount
	 *            年数, 可以为负数
	 * @return 调整后的整数型日期
	 */
	public int addYear(int amount) {
		this._calendar.add(Calendar.YEAR, amount);
		setIntegerProperty();
		return this._nDate;
	}

	// /**
	// * 生成日期时间型字符串
	// * @param timestamp 时间戳
	// * @return 调整后的整数型日期
	// * @see SSResource.lenDatetimeString
	// */
	// public String createDatetime(long timestamp){
	// /** 数字型格式 */
	// DecimalFormat df3 = new DecimalFormat("000");
	// DecimalFormat df2 = new DecimalFormat("00");
	//
	// Date d = new Date(timestamp);
	// Calendar c = Calendar.getInstance();
	// c.setTime(d);
	// return "" + this.getDate() + df2.format(c.get(Calendar.HOUR_OF_DAY)) +
	// df2.format(c.get(Calendar.MINUTE)) + df2.format(c.get(Calendar.SECOND)) +
	// df3.format(c.get(Calendar.MILLISECOND));
	// }

	/**
	 * 转换成字符串, 格式是"9999年99月99日"
	 */
	public String toString() {
		StringBuffer buffer = new StringBuffer(11);
		buffer.append(this.getYear());
		buffer.append("年");
		if (this.getMonth() < 10) {
			buffer.append(' '); // 补空格
		}
		buffer.append(this.getMonth());
		buffer.append("月");
		if (this.getDay() < 10) {
			buffer.append(' '); // 补空格
		}
		buffer.append(this.getDay());
		buffer.append("日");

		buffer.append(" ");

		if (this.getHour() < 10) {
			buffer.append(' '); // 补空格
		}
		buffer.append(this.getHour());
		buffer.append(":");

		if (this.getMinute() < 10) {
			buffer.append(' '); // 补空格
		}
		buffer.append(this.getMinute());
		buffer.append(":");

		if (this.getSecond() < 10) {
			buffer.append(' '); // 补空格
		}
		buffer.append(this.getSecond());
		buffer.append("");

		return buffer.toString();
	}

	/**
	 * 把当前日期改到所在周的最后一天(周日)的日期
	 * 
	 */
	public void movetoEndOfWeek() {
		this._nDate = getEndOfWeek();
		setCalendarProperty(this._calendar, this._nDate);
		return;
	}

	/**
	 * 把当前日期改到所在旬的最后一天的日期
	 * 
	 */
	public void movetoEndOfTenDays() {
		this._nDate = getEndOfTenDays();
		setCalendarProperty(this._calendar, this._nDate);
		return;
	}

	/**
	 * 把当前日期改到所在月份的最后一天的日期
	 * 
	 */
	public void movetoEndOfMonth() {
		this._nDate = getEndOfMonth();
		setCalendarProperty(this._calendar, this._nDate);
		return;
	}

	/**
	 * 把当前日期改到所在季度的最后一天的日期
	 * 
	 */
	public void movetoEndOfQuarter() {
		this._nDate = getEndOfQuarter();
		setCalendarProperty(this._calendar, this._nDate);
		return;
	}

	/**
	 * 把当前日期改到所在半年的最后一天的日期
	 * 
	 */
	public void movetoEndOfHalfYear() {
		this._nDate = getEndOfHalfYear();
		setCalendarProperty(this._calendar, this._nDate);
		return;
	}

	/**
	 * 把当前日期改到所在年的最后一天的日期
	 * 
	 */
	public void movetoEndOfYear() {
		this._nDate = getEndOfYear();
		setCalendarProperty(this._calendar, this._nDate);
		return;
	}
	
	public String formatDate() {
		StringBuffer buffer = new StringBuffer(11);
		buffer.append(this.getYear());
		buffer.append("-");
		if (this.getMonth() < 10) {
			buffer.append('0'); // 补空格
		}
		buffer.append(this.getMonth());
		buffer.append("-");
		if (this.getDay() < 10) {
			buffer.append('0'); // 补空格
		}
		buffer.append(this.getDay());

		buffer.append(" ");
		if (this.getHour() < 10) {
			buffer.append('0'); // 补空格
		}
		buffer.append(this.getHour());
		buffer.append(":");

		if (this.getMinute() < 10) {
			buffer.append('0'); // 补空格
		}
		buffer.append(this.getMinute());
		buffer.append(":");

		if (this.getSecond() < 10) {
			buffer.append('0'); // 补空格
		}
		buffer.append(this.getSecond());
		return buffer.toString();
	}

}
